				     
                             
                             - D I S I D E N T S - H A C K  J O U R N A L -

                                               Numero 2
                                                 XV









                                             TITLE: INTRODUCION A LA PROGRAMACION EN C BAJO WIN 
                                             Author: Crypto & DDiego 
                                             DISIDENTS ESPAA 2001 -  LOS FUERA DE LA LEY




-------------------------------------------------------------------------------------------------
------------[ INTRODUCION A LA PROGRAMACION EN C BAJO WIN  ]-------------------------------------
-------------------------------------------------------------------------------------------------
----[ 1.0    INTRODUCCION 									-			-	
----[ 1.1    HISTORIA                                                                           -  
----[ 1.2    QUE ES C                                                                           - 
----[ 1.3    QUE NECESITAMOS PARA PROGRAMAR EN C                                                -
----[ 1.4    CARACTERISTICAS DE C                                                               -
----[ 1.4.1  ESTRUCTURA BASICA DE UN PROGRAMA EN C                                              -
----[ 1.5    TIPOS DE DATOS EN C                                                                -
----[ 1.5.1  OPERADORES EN C                                                                    -  
----[ 1.6    EXPLICACION DEL PROGRAMA ANTERIOR                                                  -
----[ 1.5.2  OPERADORES RELACIONALES                                                            -
----[ 1.5.3  OPERADORES LOGICOS                                                                 -
----[ 1.5.4  OPERADORES A NIVEL DE BITS                                                         -
----[ 1.5.5  OPERADORES ARITMETICOS                                                             -
----[ 1.6    EXPLICACION DEL PROGRAMA ANTERIOR                                                  -
----[ 1.7    SENTENCIAS CONDICIONALES -                                                         -
----[ 1.7.1  if else                                                                            - 
----[ 1.7.2  switch                                                                             -
----[ 1.8    BUCLES -                                                                           -
----[ 1.8.1  do while                                                                           -
----[ 1.8.2  for                                                                                -
----[ 1.9    CONTADORES , ACUMULADORES y BANDERAS -                                             -
----[ 2.0    VECTORES Y PUNTEROS                                                                - 
----[ 2.0.1  VECTORES                                                                           -
----[ 2.0.2  PUNTEROS                                                                           -
----[ 2.1    FUNCIONES STANDART DE ENTRADA SALIDA LA LIBRERIA STDIO.H - 	                  -
----[ 2.1.1  printf()                                                                           -
----[ 2.1.2  scanf()													-
----[ 2.1.3  gets()													-
----[ 2.1.4  puts()													-				
----[ 2.1.5  getchar()													-		
----[ 2.1.6  putchar()													-
----[ 2.2    FUNCIONES PARA TRABAJAR CON CADENAS LA LIBRERIA   STRING.H					-
----[ 2.2.1  strpbrk() 													-
----[ 2.2.2  strtok () 													-
----[ 2.2.3  strcpy()													-			
----[ 2.2.4  strcat() 													-
----[ 2.2.5  strncat()													-	
----[ 2.2.6  strrchr()													-				
----[ 2.2.7  strchr()													-	 
----[ 2.2.8  strcmp() 													-
----[ 2.2.9  strlen()													-
----[ 2.2.10 strncpy() 													-
----[ 2.2.11 strstr()													-
----[ 2.3.0  MAS SENTENCIAS 												-	
----[ 2.3.1  goto														-
----[ 2.3.2  continue													-
----[ 2.4.0  DESPEDIDAS                                                                         -
-------------------------------------------------------------------------------------------------







-------------------------------------------------------------------------------------------------
------------[1.0 INTRODUCION: ]------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

	Hemos empezado este pequeo cursillo de c en win, nos iremos metiendo mas y mas y mas, 
comprendiendo mediante ejemplos como funciona este lenguaje y como se programa en el, abriendonos 
camino en el mundo de la programancion, pronto analizaremos programas e incluso en posteriores
cursos crearemos programas, y utilidades para hackear y comprender lo que estamos usando, saber
a fondo como y porque funciona.



-------------------------------------------------------------------------------------------------
------------[1.1 HISTORIA ]----------------------------------------------------------------------
-------------------------------------------------------------------------------------------------
	

	Bueno esta parte tampoco es primordial, para programar en c, pero un poco de historia y 
como surge y quien lo crea no viene mal. 
Cuando hablamos de c tenemos que hablar de Dennis Ritchie que fue su creador, el estandar de C
aun no estaba definido realmente, por eso el Instituto de estandartes americano establecio en 1983 el
ANSI, con un grupo comite que normalizara el lenguaje y estableciera un estandar, en  este 
proceso se trabajo 6 aos y en 1989 fue establecido el estandar, bueno menos rollo y a darle 
caa.
 


-------------------------------------------------------------------------------------------------
------------[1.2 QUE ES C ]----------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

  C es un lenguaje de programacion de proposito general es decir se utiliza para la creacion de 
aplicaciones de todo tipo desde el programa mas simple que se te ocurra, sumar dos numeros, hasta
cosas como un sistema operativo linux esta escrito en c y ensamblador enbebido en el codigo, los 
lenguajes de programacion se dividen segun diversos criterios uno de ellos es su nivel respecto 
a lo parecido que es al lenguaje natural asi se pueden dividir en lenguajes de alto medio y bajo 
nivel 

alto nivel -> usan un nivel muy parecido al lenguaje humano:
   ADA, VISUAL BASIC, COBOL son ejemplos 

bajo nivel -> ensamblador  esta claro que este lenguaje es el menos parecido al lenguaje humano

medio nivel-> en esta categoria se encuentran lenguajes que tienen instruciones de alto nivel 
pero tb permiten usar caracteristicas de un lenguaje de bajo nivel aqui es donde situariamos al 
c 

-------------------------------------------------------------------------------------------------
------------[1.3 QUE NECESITAMOS PARA PROGRAMAR EN C ]-------------------------------------------
-------------------------------------------------------------------------------------------------

	Para que el codigo que escribamos pueda convertirse en un programa necesitamos un 
compilador que es el encargado de traducir ese programa que has escrito a codigo binario que es 
el que entiende la maquina.
Podemos encontrar un compilador en http://www.delorie.com/djgpp/ , es gratis corre bajo dos y se 
podemos obtener mas informacion sobre este compilador  en http://www.elrincondelc.com/djgpp/
index.html. Puedes usar la forma automatica de instalacion o seguir los pasos de la web, para
usar la forma automatica solo necesitas ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2/
install.exe , que solo tienes que indicar en que directorio se encuentra los paquetes djgpp.
Yo me lo pille aqui http://www2.ing.puc.cl/iic1102/download/djgpp.zip, e inclui las lineas
set DJGPP=C:\DJGPP\DJGPP.ENV
set PATH=C:\DJGPP\BIN;%PATH%
en el autoexec.bat 
Ahora para compilar solo teneis que poner:
gcc -o nombrequequieras.exe nombredelcodigoquehasescrito.c


-------------------------------------------------------------------------------------------------
-------------[1.4 CARACTERISTICAS DE C ]---------------------------------------------------------
-------------------------------------------------------------------------------------------------

C es un lenguaje estrucuturado y modulado lo cual hace que la creacion de un programa y su
mantenimiento sea mucho mas sencillo en un lenguaje modulado como c no se encuentran sentencias 
que rompan el flujo de un programa 



-------------------------------------------------------------------------------------------------
------------[1.4.1 ESTRUCTURA BASICA DE UN PROGRAMA EN C ]---------------------------------------
-------------------------------------------------------------------------------------------------

/*1*/#include <stdio.h>
/*2*/#include "c:\librerias\string.h"
/*3*/ void main(void)
/*4*/  {
/*5*/     int a;
/*6*/     int b,c=0;
      
/*7*/    printf("Introduce un numero: ");
/*8*/    scanf("%d",&a);
/*9*/    printf("Introduce un numero: ");
/*10*/    scanf("%d",&b);
/*11*/    
/*12*/         c=a+b; // esto es un comentario
/*13*/printf("el numero introducido es el %d",c);/* esto es otro comentario*/	
/*14*/  } 

como veis no empezamos con el hola mundo por que es demasiado basico y esto es simplemente un 
ejemplo muy sencillito que esplicaremos mas tarde pero primero unas cosas basicas para entender 
el programa y una anotacion importante teneis que saber que c es un lenguaje case sensitive es 
decir distingue entre mayusculas y minusculas asi que tener cuidado por que para c no es lo mismo
a que A por convenio todo es es minusculas y las constantes es decir las variables que no 
cambian su valor a lo largo del programa se escriben en mayusculas



-------------------------------------------------------------------------------------------------
------------[1.5 TIPOS DE DATOS EN C ]----------------------------------------------------------- 
-------------------------------------------------------------------------------------------------

char caracteres -127 a 127 codigo ascii normal
int  numeros de -32.767 a 32.767 no admite decimales
float   seis digitos de precision
double  diez digitos de precision
void no  guarda ningun tipo de datos 

Luego podemos usar los modificadores unsigned y signed que es el que se usa por defecto con este 
modificador determinamos si queremos que nuestra variable admita numeros negativos o no esto 
ultimo es con unsigned



-------------------------------------------------------------------------------------------------
------------[1.5.1 OPERADORES EN C ]-------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Los operadores de c pueden ser relacionales, logicos, a nivel de bits, aritmeticos, punto y 
flecha, de tiempo de compilacion y los punteros que veremos mas adelante 



-------------------------------------------------------------------------------------------------
------------[ 1.5.2 OPERADORES RELACIONALES ]----------------------------------------------------
-------------------------------------------------------------------------------------------------


> mayor que 
< menor que 
>= mayor o igual que 
<= menor o igual que 
= igual a operador de asignacion  sirve para asignar un valor a una variable
!= distinto a



-------------------------------------------------------------------------------------------------
------------[ 1.5.3 OPERADORES LOGICOS ]---------------------------------------------------------
-------------------------------------------------------------------------------------------------

Con estos operadores realizamos operaciones logicas
&& and logico
|| or logico
! not logico 
== igual a este operador no se suele explicar aqui pero lo agrupo aqui por que lo usaremos cuando
queramos comparar el valor de una variable con otro valor cualquiera. 
Todos estos operadores menos el not son operadores que necesitan de dos elementos se llaman 
operadores binarios aparte de estos hay un operador llamado ternario es el ?
su sintaxis es asi ej:

comparacion ? orden 1: orden 2;
este realiza la comparacion si resulta verdadera realiza la orden 1 si es falso realiza la 
orden 2

Una pequea explicacion de los operadores logicos  

Todos los operadores logicos toman el valor verdadero o falso esto en otros lenguajes son 
variables de tipo boolean en c no esisten ese tipo de datos para c cualquier valor distinto de 0
es verdadero y el 0 se considera falso

 las tres operaciones logicas  son:

and : esto devuelve verdadero cuando las dos condiciones son verdaderas 
or: devuelve verdadero nada mas que una de las dos condiciones sea verdadera 
not: este operador niega el operador que le sigue
las tablas de verdad son las que le siguen (un 1 simboliza verdadero y el 0 falso


  x	  y	  and	  or	   not
--------|-------|-------|--------|--------|
  1	|  0	|  0	|  1	 |	  |                                              --------|-------|-------|--------|--------|
  1	|  1	|  1	|  1	 |	  |                                              
--------|-------|-------|--------|--------|
  0	|  0	|  0	|  0	 |	  |                                              --------|-------|-------|--------|--------|
  0	|  1	|  0	|  1	 |	  |
--------|-------|-------|--------|--------|
  1	|       |       |        |  0     |                
--------|-------|-------|--------|--------|
  0	|	|	|	 |  1	  |                                              --------|-------|-------|--------|--------| |




-------------------------------------------------------------------------------------------------
------------[1.5.4 OPERADORES A NIVEL DE BITS ]--------------------------------------------------
-------------------------------------------------------------------------------------------------


Gracias a este tipo de operadores puedes realizar operaciones a bajo que se pueden realizar en
asm "ensamblador",

&  and binario
|  or binario
^  O (XOR) binario
~  Complemento a uno
<< Desplazamiento a la izquierda
>> Desplazamiento a la derecha  

Este tipo de operadores se diferencian entro los logicos entre otras cosas que  los logicos
dan 2 valores que pueden ser 0 o 1, pero en este caso pueden dar cualquier resultado, pongamos 
ejemplo de una operacion entre bits con &

    1100100    100 en binario
    1011010     90 en binario
&   -------
    1000000


-------------------------------------------------------------------------------------------------
------------[1.5.5 OPERADORES ARITMETICOS ]------------------------------------------------------
-------------------------------------------------------------------------------------------------


Se usan para realizar operaciones aritmeticas, "suma, resta, incremento, decremento etc...)

+     suma
-     resta
*     multiplicacion
/     division
%     modulo     (resto de una division)
--    decremento (aade 1 a el valor del operando)
++    incremento (disminuye 1 al valor del operando)

ej:

x=1;
x++;
quedaria x=2

x=x+25;
x++;
entonces x=26

Tambien puede haber otras expresiones como que el ++ este delante de la variable

x=25;
y=++x;

Ahora y toma el valor y=26  , x=26

pero si escribimos

x=25;
y=x++;

en este caso y=25 y x=26






 





-------------------------------------------------------------------------------------------------
------------[1.6 EXPLICACION DEL PROGRAMA ANTERIOR ]---------------------------------------------
-------------------------------------------------------------------------------------------------


Las lineas 1 y 2: empiezan con el simbolo # este simbolo indica que eso es una directiva de 
procesador  esto quiere decir que es una forma de darle unas ordenes a la hora de compilar hay 
le estamos indicando que si encuentra una funcion (mas adelante os explicare lo que es) cuyo 
cuerpo  no esta definido por nosotros tendra que buscarlo en esas librerias una libreria es un 
conjunto de rutinas es decir  funciones que se encuentran en un programa aparte y que tienen  
el codigo que se tiene que usar  cuando hacemos una llamada a esa funcion   esto es una 
introducion para que no os suene demasiado mal por que las funciones son muy utilizadas en c y 
hablaremos mucho de ellas. 
Hay le estamos indicando en que librerias debe buscar esas funciones cuando no las vea en el 
codigo si os fijais podeis ver que e usado dos y cada una la he indicado de una manera diferente 
la primera le he puesto el nombre de la libreria entre < > esto le indica que tiene que buscar 
en el directorio por defecto se suele llamar include  la otra forma es indicarle la ruta del 
directorio entre " ".


/*1*/#include <stdio.h>
/*2*/#include "c:\librerias\string.h"

- Esto que tiene a la  izquierda que va entre /* y  */ son comentarios del programa




Linea 3: esta es una linea que siempre vereis en un programa ejecutable esto es la funcion que 
indica donde empieza a ejecutarse el programa por eso se llama main  aqui veis que tiene la 
palabra void antes del nombre de la funcion main() asi indica que no devuelve ningun tipo de 
datos y tambien tiene un void dentro de los parentesis asi indicas que no le pasas ningun 
parametro por ahora quedaros con esto dentro de na esplico que son las funciones 

/*3*/ void main(void)




Linea 4: aqui solo hay una llave de apertura esto las llaves marcan segmentos de codigo todo el
codigo del programa tiene que estar dentro de un segmento de codigo si no no se ejecutaria y 
ademas hay que cerrar todos los segmentos de codigo con otra llave de cerrado '}'

/*4*/  {



Linea 5: en esta sentencia declaramos una variable de tipo entero con signo 

/*5*/     int a;


Linea 6: en esta declaramos dos variables de tipo tb entero y a una de ellas (la c) le asignamos 
un valor es decir la igualamos a 0 si os fijais asi veis que se pueden declarar varias variables
del mismo tipo indicando solo una vez su tipo y separandolas por comas ','

/*6*/     int b,c=0;
      


Linea 7: en esta linea hacemos uso de una funcion llmada printf() que se le pasa como argumento 
una cadena entrecomillado con comillas dobles esta funcion lo que hace es sacar un mensaje por 
pantalla 

/*7*/    printf("Introduce un numero: ");



Linea 8: en esta linea recogemos un numero entero introducido por teclado con una funcion llamada
scanf() y lo guardamos en la variable a

/*8*/    scanf("%d",&a);



Linea 9 y linea 10: repetimos lo anterior solo que esta vez recogemos el valor en la variable b

/*9*/    printf("introduce un numero: ");
/*10*/    scanf("%d",&b);


Linea 12: en esta linea hacemos la suma c=a+b esto quiere decir que sumemos el valor que tiene 
la variable a y la variable b y guardemos su contenido en la variable c ademas  en esta linea 
indicamos un comentario esto es un cacho de programa que no genera codigo y sirve para darle mas 
claridad al programa en c hay dos formas de indicar un comentario medinate estas dos barras //
asi creamos un comentario que ocupara toda la linea desde las dos barras la otra forma es 
medinate /* este simbolo sirve para iniciar un comentario que terminara cuando encuentre el 
simbolo de cerrado que es este */ este tipo de comentario puede ocupar mas de una linea 

/*12*/         c=a+b; // esto es un comentario




Linea 13: en esta volvemos a utilizar la funcion printf() para sacar una cadena pero en este 
caso sacamos tb el valor que tiene la variable c y adema sos muestro otro un ejemplo del otro 
tipo de comentario que se puede usar 

/*13*/printf("el numero introducido es el %d",c); /* esto es otro comentario*/



Linea 14: se pone una llave de cierre '}' para indicar que termina el segmento de flujo las 
llaves de cierre cierran la llave de apertura que tienen encima esta solo tiene la que hemos
puesto al principio depues d ela funcion main() asi indicamos donde termina el codigo del
programa

/*14*/  } 




NOTAS:

Si os habeis fijado todas las sentencias cuando terminan se tiene que poner un ';' menos al 
principio de la funcion main por que si lo pusiesemos todo el codigo de detras no serviria de 
nada y en las llaves. 



-------------------------------------------------------------------------------------------------
------------[1.7 SENTENCIAS CONDICIONALES ]------------------------------------------------------
-------------------------------------------------------------------------------------------------


-------------------------------------------------------------------------------------------------
------------[1.7.1 SENTENCIA IF ELSE ]-----------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sentencia condicional es el if then else en esta sentencia  comprobamos el valor de una 
condicion si nos da verdadero el flujo de programa ira por el then en caso contrario no ejecutara
esas ordenes y ira a ejecutar las sentencias que se encuentre en el else un ejemplo.

 if(condicion)
   {
    orden 1;
    orden 2;
   }
 else
   orden 3;



Aqui se evaluara la condicion ej a>b si esta sentencia es verdadera realizara las ordenes 1 y 2
si es falsa realizara la orden 3 otra cosilla basica sobre las llaves es que en cualquiera de 
estas sentencias que estamos viendo si se tienen que ejecutar mas de una orden como en el then
se pone entre llaves si solo es una las llaves no son necesarias

Ejemplo:

#include <stdio.h>
main()
{
 int a=1,b=0;
 if (a>b)
        {
         printf("%d es mayor que %d\n",a,b);
	} 
 else
 printf("Aqui no llega ni de coa\n");
}
   

SALIDA:


C:\Miscositas\C\programar>gcc -o ifelse if.c
C:\Miscositas\C\programar>ifelse
1 es mayor que 0



-------------------------------------------------------------------------------------------------
------------[1.7.2 SENTENCIA SWITCH ]------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sentencia switch sirve para dado un valor realizar unas ordenes determinadas segun el valor 
que esta tenga 

switch(opcion)
{
 case 1: orden 1;
         orden 2;
         break;
 case 2:  orden 3;
          orden 4;
          orden 5
          break;
 default: orden 6;
  
}

En este ejemplo vemos que se compueba el valor que tiene opcion si este es uno se realizaran 
las ordenes 1 y 2 si el valor de opcion es 2 se realizaran las ordenes 3 y 4  en caso de que el 
valor de opcion sea cualquier otro se realizaran las ordenes de la sentencia default puede haber 
tantos case como nos de la gana y podemos compararlo con numeros cadenas etc ej:

switch(opcion)
{
  case "hola": orden 1;
               break;
  case "adios": orden 2;
}

La opcion default es opcional no es obligatorio ponerla asi como vereis tambien la sentencia 
break;
Esta sentencia rompe la ejecucion normal del programa que seria seguir hacia abajo y sigue 
despues del fin del switch esto sirve para que ejecute solo las sentencias que nos interese y no 
ejecute las ordenes pertenecientes a otra opcion 
     
Con esta sentencia podremos crear menus, por ejemplo:


#include <stdio.h>
main() 
{
 char c;
 printf("1. Opcion primera\n");
 printf("2. Opcion segunda\n");
 printf("Introduzca una opcion ");
 c=getchar(); /*Aqui lee el numero que elijas*/
 switch(c) 
         {
          case '1':
          printf("Has elegido la primera opcion\n");
          break;
          case '2':
          printf ("Has elegido la primera opcion\n");
          break;
          default:
          printf("Nos has seleccionado ninguna opcion\n");
	 }		
}


SALIDA:


C:\Miscositas\C\programar>switch
1. Opcion primera
2. Opcion segunda
Introduzca una opcion 0
Nos has seleccionado ninguna opcion

-Vemos como al sealar el 0 sale la opcion default


------------------------------------------------------------------------------------------------- 
------------[1.8 BUCLES ]------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Los bucles son sentencias que hacen que se ejecute parte del codigo mas de una vez normalmente 
estas son:


-------------------------------------------------------------------------------------------------
------------[1.8.1 do while  ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

do while(condicion)
{
sentecia 1;
sentencia 2;
}

Este bucle realiza las dos condiciones que hay entre las llaves todas las veces que sea necesario
hasta que se de que la condicion es falsa

do
{
orden 1;
orden 2;
}while(condicion);

Este funciona igual que el anterior solo que nos aseguramos que se realiza por lo menos una vez 
primero ejecuta las ordenes y despues compruba la condicion si es verdadera se sigue ejecutando
hasta que esta condicion sea falsa



-------------------------------------------------------------------------------------------------
------------[1.8.2 for  ]------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------


for(valor inicial;valor final;incremento)
 {
  orden 1;
  orden 2;
  orden 3;
 }

Este bucle se realiza un numero determinado de veces se realiza desde el valor inicial que toma 
la variable hasta que su valor sea igual mayor o menor que el valor final y se va incrementando 
de la forma en como nostros le digamos 

ej for(x=1;x<=10;x++)
{
  printf("hola");
  y=Y+1;

}

La condicion es lo que esta entre parentesis lo podriamos leer como inicializamos una variable x 
ya declarada a un valor incial de 1 con la instrucion x=0 luego comparamos el valor que tiene x
con el valor final si este es inferior o igual mediante la comparacion x<=10 se incrementara en 
uno el valor de x medinate la instrucion x++ y se realiza las instruciones entre llaves y se 
vuelve a comparar el valor de la x si sigue siendo inferior se incrementa en uno y se realizan 
las ordenes y asi hasta que x sea igual a 10 


Ahora crearemos un bucle infinito con for(;;)

for(;;) 
printf("Esto no parara de repetirse\n");



-------------------------------------------------------------------------------------------------
------------[1.9 CONTADORES , ACUMULADORES y BANDERAS ]------------------------------------------ 
-------------------------------------------------------------------------------------------------

Lo contadores son variables que nos permiten ir contando aumentando o disminuyendo de un valor 
inicial son del tipo 

void main(void)
{
  int x=0,y=10;
 x=x+1; /* en esta sentencia x cada vez que se ejecute la sentencia se incrementa en uno el 
           valor    de la x*/
   
 y =y-1; /* en esta otra sentencia se decrementa el valor de y que al principio valia 10
            en c estas dos sentencias tienen una forma abreviada por llamarlo de alguna 
            manera estas son:*/
x++; /*es igual a*/ x=x+1;
x--; /*es igual a*/ x=x-1;
}

Acumuladores este tipo de variables son variables que nos sirven para guardar un valor e ir 
sumandole o restandole valores al valor que ya tenian 

void main(void)
{
 int num, int resultado=0;
 resultado=resultado+num;
 resultado=resultado-num;
/*en c tb hay unas sentencias para abreviar estas son resultado=+x;y resulado=-x;*/
}

Las banderas nos pueden servir para representar valores booleanos en c, son variables que toman 
dos valores del estilo de true o false ,verdadero o falso 
asi luego nosotros coprobamos el valor de la variables o asi sabemos si se a producido una 
situacion que estabamos esperando

ej:

/*Programa que pide numeros hasta que introducimos el numero 0 y si introducimos uno negativo 
dira numero ilegal y pedira, hayara la media  de los numeros  que nos han introducido menos los
que sean numeros ilegales y al final nos mostrara el numero de numeros ilegales  introducidos y 
la media de los otros numeros*/

#include <stdio.h>
 void main(void)
 {
   int num, int numIlegales=0,numLegales=0 total=0;
   int  media=0, bandera=0;

 printf("introduce un numero: ");
 scanf("%d",&num);
   while(num) /* este while se realizara hasta que el num sea 0 el 0 se considera falso por lo que rompera el while*/
    {
      if(num<0) // comprobamos que el numero es menor que 0 si es menor ponemos la bandera a 1 
          bandera=1;
           if(bandera) /* si la bandera vale uno entrara por el them y ejecutara el mensaje y sumara uno al contador de numIlegales*/
            { 
              printf("numero ilegal");
              numIlegal++;
              bandera=0;
            }
            else // en caso contrario hace lo siguiente
             {
               total=+num;
               numLegal++;
             }
      printf("introduce un numero: ");
      scanf("%d",&num);
 }

printf"el numero de numeros ilegales a sido: %d",numIlegal); // muestra el numero de numIlegales
media=total/numLegal ;
printf("la media es %d:",media);//muestra la media
}

-------------------------------------------------------------------------------------------------
------------[2.0 VECTORES Y PUNTEROS ]-----------------------------------------------------------
-------------------------------------------------------------------------------------------------

Vamos a ver varias funciones de acceso a los datos, y a  la memoria


-------------------------------------------------------------------------------------------------
------------[2.0.1 VECTORES ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Los vectores son la manera que tiene c de guardar datos de una forma consecutiva es decir como 
agrupados si sintaxis es tipo del vector  nombre del vector[num de posiciones] hay que tener en 
cuenta que los vectores en c siempre empiezan en 0  pero necesitan una posicion mas de las que 
nosotros necesitemos para indicar la marca de final del vector "\0"

ej 

int numeros[5];

En un vector como el del ejemplo se pueden guardar 5 numeros enteros  diferentes desde la 
posicion 0 a la 4 son 5 numeros y luego en la quinta posicion se guarda el \0 y luego podemos 
referirnos a ellos por separado indicando su numero de posicion  ej: n=numeros[2];eso guarda en 
n el numero entero que tuviese el vector numeros en la posicion 2
Si recordais un char solo sive para guardar una letra por lo cual como hacer para guardar una 
cadena es decir un nombre como perico o cosas asi habra que usar un vector si vamos a guardar
un nombre y suponemos que ese nombre no va a superar las 15 letras pues declararemos un vector de
letras de 20 y hay guardamos el nombre seria asi 

#include <stdio.h>
 void main(void)
 {
   char nombre[20]; // declaramos la variable
   printf("Introduce el nombre: "); 
   gets(nombre);// recogemos la variable
}


Ademas los vectores pueden ser de mas de una dimension 
por ejemplo para hacer uso de una matriz de por ejemplo 4 filas y  4 columnas 


int matriz [4][4] para referirnos a una posicion el primer indice se refiere a fila y el 
siguiente a columna por ejemplo en el ejemplo anterior para referirnos a la fila 2 columna 3 
usariamos

matriz[1][2]; hay que darse cuenta que empiezan en 0 los indices 

esto es una pequea introducion con el uso surgiran algunas preguntas y os afianzareis en su uso
no es muy problematico 


-------------------------------------------------------------------------------------------------
------------[2.0.2 PUNTEROS ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Bueno cuando se habla de punteros, se suele pensar que es un tema muy complicado, intentaremos
que sea todo lo contrario mediante ejemplos. Te preguntaras que es un puntero, pues es una 
variable que apunta a la direccion de la memoria de otra variable, con esto conseguimos indicar
en una funcion donde estan los datos, para usar los punteros se usan dos tipos de operadores
& y *.
& devuelve la direccion de la memoria de su operando, por ejemplo:

a = &pass
pone en a la direccion de memoria de la variable pass, la direccion en la memoria no tiene
que ver con el valor de la variable, si la direccion en la memoria de pass esta en 3000 y tiene
el valor de 200, a solo recibe la direccion de memoria , y a "a" se le es asignado la posicion de 
memoria 3000 para contener su valor

* Por el contrario este operador devuelve el valor de la variable, osea en este caso defines al 
variable  como un puntero

admin  = *a 
en este caso admin recibe en la direccion de la memoria  de a recibe el valor de a


Veamos un ejemplo mas claro:





#include <stdio.h>
void main(void)
{
int x;
int *p1, *p2; /* 2 punteros a un entero int*/
p1=&x; /*direccion en memoria de x en pw*/
p2=p1;/*p2 se carga la direccion contenida en p1*/
printf("%p",p2);/*imrprime la direccion de p2 que es la direccion de x*/
}


SALIDA:


C:\programar>punteros
4b694


-- otro ejemplo (punteros apuntando a cadenas de caracteres);

#include <stdio.h>
main ()
      {
       char *pmsg=("Este puntero apunta a una cadena de caracteres\n");
       printf(pmsg);
      }  


SALIDA:

C:\programar>hola
Este puntero apunta a una cadena de caracteres




-- otro ejemplo (punteros y enteros);

#include <stdio.h>
main ()
{
     int entero=10;
     int *p=&entero;
      printf("El puentero es %d como el entero que tambien es %d\n", *p,entero);
}

SALIDA:


C:\programar>hola
El puentero es 10 como el entero que tambien es 10


--






Bien ya veremos mas cosas sobre punteros en los siguientes ejemplos saldra alguno  y poco a
poco lo comprendereis mejor, bueno con lo explicado hasta ahora  todavia nos falta algo basico 
que son las funciones de entrada y salida basicas abreviadamente I/O es decir poder escribir en 
pantalla y poder recoger datos del teclado  ya las hemos usado en los programas pero todavia no
estan explicadas ahora esplicaremos las mas basicas.


-------------------------------------------------------------------------------------------------
------------[2.1 FUNCIONES STANDART DE ENTRADA SALIDA LA LIBRERIA STDIO.H ]----------------------	
-------------------------------------------------------------------------------------------------

Cuando querais usar alguna de las funciones basicas de entrada  o salida tendreis que usar la 
libreria stdio.h 


-------------------------------------------------------------------------------------------------
------------[2.1.1 printf() ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis de esta funcion es int printf( const char *formato[,argumetos1...]); , La funcin 
printf retorna el nmero de caracteres transmitidos, o un valor negativo si se produce
un error de salida, se le pasa una cadena que es la que queremos que salga por pantalla y si 
necesitamos sacar alguna variable se indica mediante el simbolo % seguido se indican 
especificaciones de formato como por ejemplo el numero de decimales que tiene que monstrar su 
justificacion alineado a la izquierda a la derecha si queremos que saque el signo  etc
- indica que se tiene que aliar a la izquierda 
+ hara que salga el signo de los valores ya sea positivo o negativo 
 un blanco hara que en caso de ser positivo no se saque el signo si es negativo sacara su signo 
esto eran flags
en cuanto al tamao
n al menos n caracteres seran displayados si su longitud es menor que n el resto seran rellenados
con blancos 0n al menos n caracteres seran displayados si su longitud es menor que n el resto 
seran rellenados con 0
precision
.n indica que por lo menos se displayaran n decimales el punto es necesario
despues de todos estos ,que son opcionales se  pondra un caracter que indica el tipo de variable 
que va a displayar

%d  entero decimal con signo  int
%o  octal sin signo
%x  hexadecimal sin signo  (letras minusculas)
%X  hexadecimal sin signo (letras mayusculas)
%f  coma flotante float
%c  char caracter
%s  cadena de caracteres "strings"
%p  puntero
%e  Notacion cientifica e minuscula
%E  Notacion cientifica E mayuscula
%h  entero corto "short int"
%u  decimales enteros sin signo "unsigned int"
%ld entero largo "long int" 
%lf double
%i  entero decimal con signo
%hd entero corto en hexadecimal
&n  puntero a una variable
todo lo espuesto hasta ahora va entre comillas despues se pone una coma ',' el nombre de la 
variable que corresponde al primer % otra coma la variable que corresponde al segundo etc
esto ultimo solo es necesario si vamos a monstrar el valor de una variable 
ej:

#include <stdio.h>

void  main(void)
{
   char nombre[20];
   unsigned int edad=0;

   printf( "Escriba su nombre: " );
   scanf( "%s", nombre );
   printf( "Escriba su edad: " );
   scanf( "%d", &edad );

   printf("Hola %s. Tienes %d aos.", nombre, edad );

}


-------------------------------------------------------------------------------------------------
------------[2.1.2 scanf() ]---------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis de esta funcion es la siguiente int scanf( const char *format  argument]... ); esta 
funcion recoje de la entrada estandar(teclado) indicandole el tipo de datos que recoge  es decir
es una entrada con formato indicandole los datos que recojemos mediante los modificadores "%d" ,
"%s","%f" etc y como valor de retorno devuelve el numero de argumentos bien leidos 


-------------------------------------------------------------------------------------------------
------------[2.1.3 gets () ]---------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis de esta funcion es  char *gets( char *buffer ); nos sirve para recoger por la entrada
 estandar una cadena  sin indicar ningun formato

-------------------------------------------------------------------------------------------------
------------[2.1.4 puts() ]----------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis de esta funcion es int puts(const char *cadena); Esta funcin escribe la cadena 
apuntado por cadena y aade un carcter de lnea nueva a la salida. El carcter nulo final 
no es escrito. Devuelve 0 si hay algun error y un numero mayor de 0 si todo ha salido bien el 
valor que devuelve en realidad es EOF es una macro  Una expresin entera constante y negativa 
que es retornada por varias funciones para indicar un final de fichero (End Of File), esto es, 
no hay ms datos de entrada de un stream.
 

ej de puts y gets 


#include <stdio.h>
void main(void)
{
    char  nombre[30];
   printf("introduce tu nombre: ");
  gets(nombre);
  printf("tu nombre es: ");
  puts(nombre);
}


-------------------------------------------------------------------------------------------------
------------[2.1.5 getchar() ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Lee un caracter del teclado y espera un salto de carro osea el enter, su sintaxis es 
int getchar(void); , veamos como se utiliza en un ejemplo cuando veamos el putchar() los veremos 
los dos a la vez




-------------------------------------------------------------------------------------------------
------------[2.1.6 putchar ]---------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Imprime en pantalla, un caracter, sintaxis: int putchar(int c); 


#include <stdio.h> 
	
main()
     {
      int c;
      printf ("Para salir del programa calca la u\n");
      printf ("Escribe lo que quieras, y calca enter ");
            do
      {
      c= getchar(); /*Recibe un caracter*/
      putchar (c); /*Lo imprime en pantalla*/  
      }
      while (c !='u'); /*mientras c sea distina de u*/
      printf("\nChau loco\n");
      return 0;
      }   

SALIDA:


C:\programar>hola
Para salir del programa calca la u
Escribe lo que quieras, y calca enter jj
jj
u
u
Chau loco













-------------------------------------------------------------------------------------------------
------------[2.2 FUNCIONES PARA TRABAJAR CON CADENAS LA LIBRERIA   STRING.H ]--------------------
-------------------------------------------------------------------------------------------------

La libreria string.h tiene muchas funciones para hacernos mas facil trabajar con vectores algunas
de las principales funciones son


-------------------------------------------------------------------------------------------------
------------[2.2.1 strpbrk() ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis es char *strpbrk(const char *s1, const char *s2); Localiza la primera aparicin de la
cadena apuntada por s1 de cualquier carcter de la cadena apuntada por s2. Como valor de retorno 
tiene en caso de encontrarlo la cadena donde lo ha encontrado en caso contrario devuelve NULL 
NULL es una macro que tiene el mismo valor que un 0

/* Ejemplo de strpbrk  */
#include <stdio.h>
#include <string.h>

main ()
{
  char str[] = "Hola cohete man"; /* Aqui buscara los caracteres de abajo*/
  char caracter[] = "wfaola"; /*Buscara estos caracteres*/
  char *buscar;
  printf ("Dentro la frase '%s' se encontraron los caracteres: ",str);
  buscar = strpbrk (str, caracter); /*Aqui empieza el tema*/
  while (buscar != NULL) /*mientras encuentre caracteres*/
  {
    printf ("%c " , *buscar); /*Aqui aparecen los caracteres encontrados*/
    buscar = strpbrk (buscar+1,caracter); /*Si no pones +1 no sigue al siguiente y te pone el
                                            primer caracter en este caso oooooooo sin parar
                                            compruebalo,  si lo pones busca encuentra y sigue 
                                            siguiente*/
  }
  printf ("\n");
  return 0;
}


SALIDA:
Dentro la frase 'Hola cohete man' se encontraron los caracteres: o l a o a



-------------------------------------------------------------------------------------------------
------------[2.2.1 strpbrk() ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis es char *strtok(char *s1, const char *s2);

Rompe la cadena s1 en segmentos o tkens. Esta ruptura destruye s1, en el proceso. La forma de
romper la cadena depende de la secuencia de caracteres de la cadena s2. Estos caracteres se 
denominan [caracteres] delimitadores. La funcin recorrer la cadena en busca de alguno de los 
delimitadores de la cadena s2. Cuando lo encuentre, el proceso se detiene, ya que tiene un token. 
Posteriores llamadas a strtok rompern la cadena s1 en otros tkens. Estas llamadas pueden tener
otra secuencia de delimitadores
Como valor de retorno cada llamada a strtok() rompe la cadena en donde encuente el primer 
caracter delimitador  en caso de no encontrarlo devuelve NULL 

#include <stdio.h>
#include <string.h>

int main()
{
   char s1[30] = "Hola esto es una prueba";
   char s2[5] = " \n\t";
   char *acortar;

   printf( "s1=%s\n", s1 );

   acortar = strtok( s1, s2 );   
   printf( "%s\n", acortar );
   while( (acortar = strtok( NULL, s2 )) != NULL )   
     printf( "%s\n", acortar );

   return 0;
}



SALIDA:

s1=Hola esto es una prueba
Hola
esto
es
una
prueba


-------------------------------------------------------------------------------------------------
------------[2.2.3 strcpy() ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es char *strcpy(char *s1, const char *s2); Copia la cadena apuntada por s2 
(incluyendo el carcter nulo) a la cadena apuntada por s1, como valor de retorno devuelve la 
funcion copiada si ocurre algo "extrao" su comportamiento no esta definido 

#include <stdio.h>
#include <string.h>

int main()
     {
     char cadena[] = "Tomar unos disparos, tengo sed";
     char vale[30];

     strcpy( vale, cadena ); /*Copia la cadena en vale*/
     printf( "Que quieres hacer?? %s\n", vale ); 
     }


SALIDA:

C:\programar>strcpy
Que quieres hacer?? Tomar unos disparos, tengo sed



-------------------------------------------------------------------------------------------------
------------[2.2.4 strcat() ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

La sintaxis es char *strcat(char*s1, const char *s2);

Aade una copia de la cadena apuntada por s2 (incluyendo el carcter nulo) al final de la cadena 
apuntada por s1. El carcter inicial de s2 sobrescribe el carcter nulo al final de s1. 
como valor de retorno devueleve la copia de la cadena en s1 en caso de que salga mal el 
comportamiento no esta definido primero tendremos que controlar nosotros la longitud de las 
cadenas 

#include <stdio.h>
#include <string.h>

int main()
         {
         char miembro[20];
         char nick[]="DDiego";
         char ident[]="Disidents";
   
         strcpy( miembro, nick ); /*Copia nick en miembro*/
         strcat( miembro, " " ); /*Espacio*/
         strcat( miembro, ident );
         printf( "Su nombre y su ident es ==> %s\n", miembro );
         }



SALIDA:

C:\programar>strcat
Su nombre y su ident es ==> DDiego Disidents


-------------------------------------------------------------------------------------------------
------------[2.2.5 strncat() ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es char *strncat(char*s1, const char *s2, size_t n);
Aade no ms de n caracteres (un carcter nulo y los dems caracteres siguientes no son aadidos)
de la cadena apuntada por s2 al final de la cadena apuntada por s1. El carcter inicial de s2 
sobrescribe el carcter nulo al final de s1. El carcter nulo siempre es aadido al resultado
como valor de retorno copia al final de la cadena los caracteres aadidos en caso contrario el 
comportamiento no esta definido 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char buffer[80];

int main( void )
  {
    strcpy( buffer, "Hola " );
    strncat( buffer, "cohete",6 );
    printf( "%s\n", buffer );
   }


SALIDA:

C:\programar>hola
Hola cohete


-------------------------------------------------------------------------------------------------
------------[2.2.6 strrchr() ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------
Su sintaxis es char *strrchr(char *s, int c);
Localiza la ltima aparicin de c (convertido a unsigned char) en la cadena apuntada por s 
(incluyendo el carcter nulo). 
como valor de retorno devuelve la cadena encontrada en caso contrario devuelve NULL

#include <stdio.h>
#include <string.h>

main ()
{
  char str[] = "Hola cohete man";
  char * caracter;
  printf ("En que posicion se encuentra el caracter \"e\" en la frase '%s'\n",str);
  caracter=strrchr(str,'e');
  while (caracter!=NULL)
  {
    printf ("la posisicion %d\n",caracter-str+1);
    caracter=strchr(caracter+1,'e');
  }
  return 0;
}

SALIDA:

En que posicion se encuentra el caracter "e" en la frase 'Hola cohete man'
la posicion 11

jeje recuerda que cuentan los espacios 


-------------------------------------------------------------------------------------------------
------------[2.2.7 strchr() ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es char *strchr(char *s, int c);
Localiza la primera aparicin de c (convertido a unsigned char) en la cadena apuntada por s 
(incluyendo el carcter nulo). 
le valor de retorno funciona igual que en strrchr()

ejemplo:

#include <stdio.h>
#include <string.h>

main ()
{
  char str[] = "Hola cohete man";
  char * caracter;
  printf ("En que posicion se encuentra el caracter \"e\" en la frase '%s'\n",str);
  caracter=strchr(str,'e');
  while (caracter!=NULL)
  {
    printf ("la posisicion %d\n",caracter-str+1);
    caracter=strchr(caracter+1,'e');
  }
  return 0;
}

SALIDA:
En que posicion se encuentra el caracter "e" en la frase 'Hola cohete man'
la posicion 9
la posicion 11

 

-------------------------------------------------------------------------------------------------
------------[2.2.8 strcmp() ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es int strcmp(const char *s1, const char *s2, size_t n);
Compara no ms de n caracteres (caracteres posteriores al carcter nulo no se tienen en cuenta) 
de la cadena apuntada por s1 con la cadena apuntada por s2. 
Valor de retorno:
 en caso de que sean iguales devuelve 0 si s1 es mayor que s2 devuelve un valor mayor que  0 si
s2 es mayor de s1 devuelve un numero menor que 0


#include <stdio.h>
#include <string.h>

main ()
{
  char respuesta[] = "vodka con limon";
  char entrada [30];
  int x; 
  do {
     printf ("Que bebe DDiego cuando tiene sed: ");
     gets (entrada);
     }
 while (strcmp (respuesta,entrada) !=0);
  printf ("Tu si que lo conoces\n"); /*Si la entrada coincide con la respuesta da esta salida*/
  return 0;
}


SALIDA:

Que bebe DDiego cuando tiene sed: vodka con limon
Tu si que lo conoces


-------------------------------------------------------------------------------------------------
------------[2.2.9 strlen() ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es size_t strlen(const char *s);
Calcula el nmero de caracteres de la cadena apuntada por s. 
Valor de retorno: 
devuelve el numero con la longitud de la cadena

#include <stdio.h>
#include <string.h>
main()
     {
      char texto[50];
      int tamano;
      printf("Escribe tu nombre: ");
      scanf("%s",&texto);
      tamano=strlen(texto);
      printf("La cadena %s tiene un tamao de %d caracteres\n",texto,tamano);
     }    
 


SALIDA:


C:\programar>hola
Escribe tu nombre: DDiego
La cadena DDiego tiene un tamao de 6 caracteres



-------------------------------------------------------------------------------------------------
------------[2.2.10 strncpy() ]------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es char *strncpy(char *s1, const char *s2, size_t n);
Copia no ms de n caracteres (caracteres posteriores al carcter nulo no son copiados) de la 
cadena apuntada por s2 a la cadena apuntada por s1.

Valor de retorno:
la cadena copiada en caso de que haya algun problema su valor no esta definido

Ver el ejemplo de strncat ()



-------------------------------------------------------------------------------------------------
------------[2.2.11 strstr() ]-------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Su sintaxis es char *strstr(const char *s1, const char *s2);
Localiza la primera aparicin en la cadena apuntada por s1 de la secuencia de caracteres
(excluyendo el carcter nulo) en la cadena apuntada por s2. 
Valor de retorno:
la cadena encontrada en caso de no encontrarlo  devuelve NULL

#include <stdio.h>
#include <string.h>
main ()
{
  char cadena[] ="Esto es una putada grandisima";
  char * operacion;
  operacion = strstr (cadena,"putada"); /*Aqui la busca en cadena*/
  strncpy (operacion,"mierda",5); /*copia mierda en operacion jejeje */
  puts (cadena); /*imprime en pantalla*/
  return 0;
}


SALIDA:

C:\programar>strstr
Esto es una mierda grandisima



-------------------------------------------------------------------------------------------------
------------[2.3.0  MAS SENTENCIAS  ]------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Vamos a ver mas sentencias entre ellas goto y continue


-------------------------------------------------------------------------------------------------
------------[2.3.1  GOTO ]-----------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Esta sentencia es utilizada en muchos lenguajes de programacion, sirve para dar un salto a la 
parte del programa que queramos, su sintaxis es : goto etiqueta;

ejemplo:

#include <stdio.h>

main ()
      {
       char nombre[20];
       pregunta:   /*Esto es la etiqueta, seguida de : */
       printf("Hola cual es tu nombre\n");
       scanf("%s",&nombre);
       printf ("Hola %s, que tal\n",nombre);
       goto pregunta;  
}        
            

SALIDA:

C:\programar>goto
Hola cual es tu nombre DDiego
Hola DDiego, que tal
Hola cual es tu nombre     <- vemos como retorna a la etiqueta pregunta: y vuelve a empezar


-------------------------------------------------------------------------------------------------
------------[2.3.2 CONTINUE ]--------------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Esta sentencia no tiene mucha complicacion es facil de  usar, y se utiliza para que no se  
acaben los programas y vuelva a empezar de nuevo el programa, su sintaxis es: continue;

ejemplo:

#include <stdio.h>

main() 
{
   int numero=1;
   while(numero<=10)/*mientras el numero sea menor = que 10*/
   {
      if (numero==5)/*Si el numero es igual a 5*/
      {
	 numero++; /*entonces saltarlo*/
	 continue; /*continuar con el programa*/
      }
   printf("%d\n",numero);
   numero++;
   }
}

SALIDA:

C:\programar>continue
1
2
3
4
6
7
8
9
10


-------------------------------------------------------------------------------------------------
------------[2.4.0  DESPEDIDAS ]-----------------------------------------------------------------
-------------------------------------------------------------------------------------------------

Bueno en el proximo capitulo mas y mejor, esperamos hacer analisis de programas mas adelante, 
para que podrais crear vuestras propias herramientas, y entender las que ya estan hechas, venga
un saludo y hasta el proximo curso de programacion, bye.









---------------------------------------------------
-       CONTACTA CONMIGO O CON EL TEAM            -
---------------------------------------------------
- NICK:     DDiego                                -
- CARGO:    Subcoordinador - editor               -
- MAIL:     DDiegodisid@yahoo.es                  -  
- TEAM:     disidents@yahoo.es                    -
---------------------------------------------------
- NICK:	    crypto                                -
- MAIL:     roko70@hotmail.com                    -	
- TEAM:     disidents@yahoo.es                    -
---------------------------------------------------



                                                  
 					                      Disidents Espaa  2001 2 edicion. 
-------------------------------------------------------------------------------------------------

                     @@-------               @@---------------  
		    @@----                  @@---------       @@@@@@@@@  
		   @@--     @@@@@--        @@-- @@@@@       @     @@  @@@@@@@@@@@@@@@@@@@@@@@@@@@@-------
              @@@@@@    @@ @@      @@ @@@@@@-  @@      @@@ @    @@  @@-----------------------------
             @@        @@ @@@@@   @@ @@---    @@@@@@   @@ @@   @@  @@@@@--------------
            @@        @@     @@  @@ @@ -     @@       @@ @@   @@      @@----------
             @@@@@@@ @@  @@@@@@ @@   @@@@@@@ @@@@@@@ @@  @@ @@	     @@--------
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@------